home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / jam / jamdisk7 / inc9110b.lzh / include / arpfunctions.inline.h < prev    next >
C/C++ Source or Header  |  1991-07-30  |  31KB  |  1,563 lines
  1. /*
  2.  * Header file created from arp_lib.typed_fd by header.typed.awk
  3.  * Run at Tuesday 30-Jul-91 21:24:07
  4.  */
  5.  
  6. #ifndef ARPFUNCTIONS_H
  7. #define ARPFUNCTIONS_H
  8.  
  9. #ifndef LIBRARIES_ARPBASE_H
  10. #include <libraries/arpbase.h>
  11. #endif
  12.  
  13. #ifndef LIBRARIES_DOSEXTENS_H
  14. #include <libraries/dosextens.h>
  15. #endif
  16.  
  17. #define DEFTYPE int
  18.  
  19. __inline static BPTR
  20. Open(const char * name, long accessMode)
  21. {
  22.     register const char * d1 __asm("d1");
  23.     register long d2 __asm("d2");
  24.     register BPTR res __asm("d0");
  25.     d1 = name;
  26.     d2 = accessMode;
  27.     __asm volatile
  28.         ("movel a6, sp@-
  29.           movel _ArpBase, a6
  30.           jsr a6@(-30)
  31.           movel sp@+, a6"
  32.         : "=g"(res): "g"(d1), "g"(d2)
  33.         : "d1", "d2", "a0", "a1");
  34.     return res;
  35. }
  36.  
  37. __inline static void
  38. Close(BPTR file)
  39. {
  40.     register BPTR d1 __asm("d1");
  41.     d1 = file;
  42.     __asm volatile
  43.         ("movel a6, sp@-
  44.           movel _ArpBase, a6
  45.           jsr a6@(-36)
  46.           movel sp@+, a6"
  47.         : : "g"(d1)
  48.         : "d0", "d1", "a0", "a1");
  49. }
  50.  
  51. __inline static long
  52. Read(BPTR file, char * buffer, long length)
  53. {
  54.     register BPTR d1 __asm("d1");
  55.     register char * d2 __asm("d2");
  56.     register long d3 __asm("d3");
  57.     register long res __asm("d0");
  58.     d1 = file;
  59.     d2 = buffer;
  60.     d3 = length;
  61.     __asm volatile
  62.         ("movel a6, sp@-
  63.           movel _ArpBase, a6
  64.           jsr a6@(-42)
  65.           movel sp@+, a6"
  66.         : "=g"(res): "g"(d1), "g"(d2), "g"(d3)
  67.         : "d1", "d2", "d3", "a0", "a1");
  68.     return res;
  69. }
  70.  
  71. __inline static long
  72. Write(BPTR file, const char * buffer, long length)
  73. {
  74.     register BPTR d1 __asm("d1");
  75.     register const char * d2 __asm("d2");
  76.     register long d3 __asm("d3");
  77.     register long res __asm("d0");
  78.     d1 = file;
  79.     d2 = buffer;
  80.     d3 = length;
  81.     __asm volatile
  82.         ("movel a6, sp@-
  83.           movel _ArpBase, a6
  84.           jsr a6@(-48)
  85.           movel sp@+, a6"
  86.         : "=g"(res): "g"(d1), "g"(d2), "g"(d3)
  87.         : "d1", "d2", "d3", "a0", "a1");
  88.     return res;
  89. }
  90.  
  91. __inline static BPTR
  92. Input(void)
  93. {
  94.     register BPTR res __asm("d0");
  95.     __asm volatile
  96.         ("movel a6, sp@-
  97.           movel _ArpBase, a6
  98.           jsr a6@(-54)
  99.           movel sp@+, a6"
  100.         : "=g"(res):
  101.         : "d1", "a0", "a1");
  102.     return res;
  103. }
  104.  
  105. __inline static BPTR
  106. Output(void)
  107. {
  108.     register BPTR res __asm("d0");
  109.     __asm volatile
  110.         ("movel a6, sp@-
  111.           movel _ArpBase, a6
  112.           jsr a6@(-60)
  113.           movel sp@+, a6"
  114.         : "=g"(res):
  115.         : "d1", "a0", "a1");
  116.     return res;
  117. }
  118.  
  119. __inline static long
  120. Seek(BPTR file, long position, long offset)
  121. {
  122.     register BPTR d1 __asm("d1");
  123.     register long d2 __asm("d2");
  124.     register long d3 __asm("d3");
  125.     register long res __asm("d0");
  126.     d1 = file;
  127.     d2 = position;
  128.     d3 = offset;
  129.     __asm volatile
  130.         ("movel a6, sp@-
  131.           movel _ArpBase, a6
  132.           jsr a6@(-66)
  133.           movel sp@+, a6"
  134.         : "=g"(res): "g"(d1), "g"(d2), "g"(d3)
  135.         : "d1", "d2", "d3", "a0", "a1");
  136.     return res;
  137. }
  138.  
  139. __inline static long
  140. DeleteFile(const char * name)
  141. {
  142.     register const char * d1 __asm("d1");
  143.     register long res __asm("d0");
  144.     d1 = name;
  145.     __asm volatile
  146.         ("movel a6, sp@-
  147.           movel _ArpBase, a6
  148.           jsr a6@(-72)
  149.           movel sp@+, a6"
  150.         : "=g"(res): "g"(d1)
  151.         : "d1", "a0", "a1");
  152.     return res;
  153. }
  154.  
  155. __inline static long
  156. Rename(const char * oldName, const char * newName)
  157. {
  158.     register const char * d1 __asm("d1");
  159.     register const char * d2 __asm("d2");
  160.     register long res __asm("d0");
  161.     d1 = oldName;
  162.     d2 = newName;
  163.     __asm volatile
  164.         ("movel a6, sp@-
  165.           movel _ArpBase, a6
  166.           jsr a6@(-78)
  167.           movel sp@+, a6"
  168.         : "=g"(res): "g"(d1), "g"(d2)
  169.         : "d1", "d2", "a0", "a1");
  170.     return res;
  171. }
  172.  
  173. __inline static BPTR
  174. Lock(const char * name, long type)
  175. {
  176.     register const char * d1 __asm("d1");
  177.     register long d2 __asm("d2");
  178.     register BPTR res __asm("d0");
  179.     d1 = name;
  180.     d2 = type;
  181.     __asm volatile
  182.         ("movel a6, sp@-
  183.           movel _ArpBase, a6
  184.           jsr a6@(-84)
  185.           movel sp@+, a6"
  186.         : "=g"(res): "g"(d1), "g"(d2)
  187.         : "d1", "d2", "a0", "a1");
  188.     return res;
  189. }
  190.  
  191. __inline static void
  192. UnLock(BPTR lock)
  193. {
  194.     register BPTR d1 __asm("d1");
  195.     d1 = lock;
  196.     __asm volatile
  197.         ("movel a6, sp@-
  198.           movel _ArpBase, a6
  199.           jsr a6@(-90)
  200.           movel sp@+, a6"
  201.         : : "g"(d1)
  202.         : "d0", "d1", "a0", "a1");
  203. }
  204.  
  205. __inline static BPTR
  206. DupLock(BPTR lock)
  207. {
  208.     register BPTR d1 __asm("d1");
  209.     register BPTR res __asm("d0");
  210.     d1 = lock;
  211.     __asm volatile
  212.         ("movel a6, sp@-
  213.           movel _ArpBase, a6
  214.           jsr a6@(-96)
  215.           movel sp@+, a6"
  216.         : "=g"(res): "g"(d1)
  217.         : "d1", "a0", "a1");
  218.     return res;
  219. }
  220.  
  221. __inline static long
  222. Examine(BPTR lock, struct FileInfoBlock * fileInfoBlock)
  223. {
  224.     register BPTR d1 __asm("d1");
  225.     register struct FileInfoBlock * d2 __asm("d2");
  226.     register long res __asm("d0");
  227.     d1 = lock;
  228.     d2 = fileInfoBlock;
  229.     __asm volatile
  230.         ("movel a6, sp@-
  231.           movel _ArpBase, a6
  232.           jsr a6@(-102)
  233.           movel sp@+, a6"
  234.         : "=g"(res): "g"(d1), "g"(d2)
  235.         : "d1", "d2", "a0", "a1");
  236.     return res;
  237. }
  238.  
  239. __inline static long
  240. ExNext(BPTR lock, struct FileInfoBlock * fileInfoBlock)
  241. {
  242.     register BPTR d1 __asm("d1");
  243.     register struct FileInfoBlock * d2 __asm("d2");
  244.     register long res __asm("d0");
  245.     d1 = lock;
  246.     d2 = fileInfoBlock;
  247.     __asm volatile
  248.         ("movel a6, sp@-
  249.           movel _ArpBase, a6
  250.           jsr a6@(-108)
  251.           movel sp@+, a6"
  252.         : "=g"(res): "g"(d1), "g"(d2)
  253.         : "d1", "d2", "a0", "a1");
  254.     return res;
  255. }
  256.  
  257. __inline static long
  258. Info(BPTR lock, struct InfoData * parameterBlock)
  259. {
  260.     register BPTR d1 __asm("d1");
  261.     register struct InfoData * d2 __asm("d2");
  262.     register long res __asm("d0");
  263.     d1 = lock;
  264.     d2 = parameterBlock;
  265.     __asm volatile
  266.         ("movel a6, sp@-
  267.           movel _ArpBase, a6
  268.           jsr a6@(-114)
  269.           movel sp@+, a6"
  270.         : "=g"(res): "g"(d1), "g"(d2)
  271.         : "d1", "d2", "a0", "a1");
  272.     return res;
  273. }
  274.  
  275. __inline static BPTR
  276. CreateDir(const char * name)
  277. {
  278.     register const char * d1 __asm("d1");
  279.     register BPTR res __asm("d0");
  280.     d1 = name;
  281.     __asm volatile
  282.         ("movel a6, sp@-
  283.           movel _ArpBase, a6
  284.           jsr a6@(-120)
  285.           movel sp@+, a6"
  286.         : "=g"(res): "g"(d1)
  287.         : "d1", "a0", "a1");
  288.     return res;
  289. }
  290.  
  291. __inline static BPTR
  292. CurrentDir(BPTR lock)
  293. {
  294.     register BPTR d1 __asm("d1");
  295.     register BPTR res __asm("d0");
  296.     d1 = lock;
  297.     __asm volatile
  298.         ("movel a6, sp@-
  299.           movel _ArpBase, a6
  300.           jsr a6@(-126)
  301.           movel sp@+, a6"
  302.         : "=g"(res): "g"(d1)
  303.         : "d1", "a0", "a1");
  304.     return res;
  305. }
  306.  
  307. __inline static long
  308. IoErr(void)
  309. {
  310.     register long res __asm("d0");
  311.     __asm volatile
  312.         ("movel a6, sp@-
  313.           movel _ArpBase, a6
  314.           jsr a6@(-132)
  315.           movel sp@+, a6"
  316.         : "=g"(res):
  317.         : "d1", "a0", "a1");
  318.     return res;
  319. }
  320.  
  321. __inline static struct MsgPort *
  322. CreateProc(const char * name, long pri, BPTR segList, long stackSize)
  323. {
  324.     register const char * d1 __asm("d1");
  325.     register long d2 __asm("d2");
  326.     register BPTR d3 __asm("d3");
  327.     register long d4 __asm("d4");
  328.     register struct MsgPort * res __asm("d0");
  329.     d1 = name;
  330.     d2 = pri;
  331.     d3 = segList;
  332.     d4 = stackSize;
  333.     __asm volatile
  334.         ("movel a6, sp@-
  335.           movel _ArpBase, a6
  336.           jsr a6@(-138)
  337.           movel sp@+, a6"
  338.         : "=g"(res): "g"(d1), "g"(d2), "g"(d3), "g"(d4)
  339.         : "d1", "d2", "d3", "d4", "a0", "a1");
  340.     return res;
  341. }
  342.  
  343. __inline static void
  344. Exit(long returnCode)
  345. {
  346.     register long d1 __asm("d1");
  347.     d1 = returnCode;
  348.     __asm volatile
  349.         ("movel a6, sp@-
  350.           movel _ArpBase, a6
  351.           jsr a6@(-144)
  352.           movel sp@+, a6"
  353.         : : "g"(d1)
  354.         : "d0", "d1", "a0", "a1");
  355. }
  356.  
  357. __inline static BPTR
  358. LoadSeg(const char * fileName)
  359. {
  360.     register const char * d1 __asm("d1");
  361.     register BPTR res __asm("d0");
  362.     d1 = fileName;
  363.     __asm volatile
  364.         ("movel a6, sp@-
  365.           movel _ArpBase, a6
  366.           jsr a6@(-150)
  367.           movel sp@+, a6"
  368.         : "=g"(res): "g"(d1)
  369.         : "d1", "a0", "a1");
  370.     return res;
  371. }
  372.  
  373. __inline static void
  374. UnLoadSeg(BPTR segment)
  375. {
  376.     register BPTR d1 __asm("d1");
  377.     d1 = segment;
  378.     __asm volatile
  379.         ("movel a6, sp@-
  380.           movel _ArpBase, a6
  381.           jsr a6@(-156)
  382.           movel sp@+, a6"
  383.         : : "g"(d1)
  384.         : "d0", "d1", "a0", "a1");
  385. }
  386.  
  387. DEFTYPE
  388. GetPacket(DEFTYPE wait);
  389.  
  390. DEFTYPE
  391. QueuePacket(DEFTYPE packet);
  392.  
  393. __inline static struct MsgPort *
  394. DeviceProc(const char * name)
  395. {
  396.     register const char * d1 __asm("d1");
  397.     register struct MsgPort * res __asm("d0");
  398.     d1 = name;
  399.     __asm volatile
  400.         ("movel a6, sp@-
  401.           movel _ArpBase, a6
  402.           jsr a6@(-174)
  403.           movel sp@+, a6"
  404.         : "=g"(res): "g"(d1)
  405.         : "d1", "a0", "a1");
  406.     return res;
  407. }
  408.  
  409. __inline static long
  410. SetComment(const char * name, const char * comment)
  411. {
  412.     register const char * d1 __asm("d1");
  413.     register const char * d2 __asm("d2");
  414.     register long res __asm("d0");
  415.     d1 = name;
  416.     d2 = comment;
  417.     __asm volatile
  418.         ("movel a6, sp@-
  419.           movel _ArpBase, a6
  420.           jsr a6@(-180)
  421.           movel sp@+, a6"
  422.         : "=g"(res): "g"(d1), "g"(d2)
  423.         : "d1", "d2", "a0", "a1");
  424.     return res;
  425. }
  426.  
  427. __inline static long
  428. SetProtection(const char * name, long mask)
  429. {
  430.     register const char * d1 __asm("d1");
  431.     register long d2 __asm("d2");
  432.     register long res __asm("d0");
  433.     d1 = name;
  434.     d2 = mask;
  435.     __asm volatile
  436.         ("movel a6, sp@-
  437.           movel _ArpBase, a6
  438.           jsr a6@(-186)
  439.           movel sp@+, a6"
  440.         : "=g"(res): "g"(d1), "g"(d2)
  441.         : "d1", "d2", "a0", "a1");
  442.     return res;
  443. }
  444.  
  445. __inline static long *
  446. DateStamp(long * date)
  447. {
  448.     register long * d1 __asm("d1");
  449.     register long * res __asm("d0");
  450.     d1 = date;
  451.     __asm volatile
  452.         ("movel a6, sp@-
  453.           movel _ArpBase, a6
  454.           jsr a6@(-192)
  455.           movel sp@+, a6"
  456.         : "=g"(res): "g"(d1)
  457.         : "d1", "a0", "a1");
  458.     return res;
  459. }
  460.  
  461. __inline static void
  462. Delay(long timeout)
  463. {
  464.     register long d1 __asm("d1");
  465.     d1 = timeout;
  466.     __asm volatile
  467.         ("movel a6, sp@-
  468.           movel _ArpBase, a6
  469.           jsr a6@(-198)
  470.           movel sp@+, a6"
  471.         : : "g"(d1)
  472.         : "d0", "d1", "a0", "a1");
  473. }
  474.  
  475. __inline static long
  476. WaitForChar(BPTR file, long timeout)
  477. {
  478.     register BPTR d1 __asm("d1");
  479.     register long d2 __asm("d2");
  480.     register long res __asm("d0");
  481.     d1 = file;
  482.     d2 = timeout;
  483.     __asm volatile
  484.         ("movel a6, sp@-
  485.           movel _ArpBase, a6
  486.           jsr a6@(-204)
  487.           movel sp@+, a6"
  488.         : "=g"(res): "g"(d1), "g"(d2)
  489.         : "d1", "d2", "a0", "a1");
  490.     return res;
  491. }
  492.  
  493. __inline static BPTR
  494. ParentDir(BPTR lock)
  495. {
  496.     register BPTR d1 __asm("d1");
  497.     register BPTR res __asm("d0");
  498.     d1 = lock;
  499.     __asm volatile
  500.         ("movel a6, sp@-
  501.           movel _ArpBase, a6
  502.           jsr a6@(-210)
  503.           movel sp@+, a6"
  504.         : "=g"(res): "g"(d1)
  505.         : "d1", "a0", "a1");
  506.     return res;
  507. }
  508.  
  509. __inline static long
  510. IsInteractive(BPTR file)
  511. {
  512.     register BPTR d1 __asm("d1");
  513.     register long res __asm("d0");
  514.     d1 = file;
  515.     __asm volatile
  516.         ("movel a6, sp@-
  517.           movel _ArpBase, a6
  518.           jsr a6@(-216)
  519.           movel sp@+, a6"
  520.         : "=g"(res): "g"(d1)
  521.         : "d1", "a0", "a1");
  522.     return res;
  523. }
  524.  
  525. __inline static long
  526. Execute(const char * string, BPTR inputFile, BPTR outputFile)
  527. {
  528.     register const char * d1 __asm("d1");
  529.     register BPTR d2 __asm("d2");
  530.     register BPTR d3 __asm("d3");
  531.     register long res __asm("d0");
  532.     d1 = string;
  533.     d2 = inputFile;
  534.     d3 = outputFile;
  535.     __asm volatile
  536.         ("movel a6, sp@-
  537.           movel _ArpBase, a6
  538.           jsr a6@(-222)
  539.           movel sp@+, a6"
  540.         : "=g"(res): "g"(d1), "g"(d2), "g"(d3)
  541.         : "d1", "d2", "d3", "a0", "a1");
  542.     return res;
  543. }
  544.  
  545. int
  546. Printf(const char * string, ...);
  547.  
  548. int
  549. FPrintf(BPTR file, const char * string, ...);
  550.  
  551. __inline static long
  552. Puts(const char * string)
  553. {
  554.     register const char * a1 __asm("a1");
  555.     register long res __asm("d0");
  556.     a1 = string;
  557.     __asm volatile
  558.         ("movel a6, sp@-
  559.           movel _ArpBase, a6
  560.           jsr a6@(-240)
  561.           movel sp@+, a6"
  562.         : "=g"(res): "g"(a1)
  563.         : "d1", "a0", "a1");
  564.     return res;
  565. }
  566.  
  567. __inline static long
  568. ReadLine(char * buffer)
  569. {
  570.     register char * a0 __asm("a0");
  571.     register long res __asm("d0");
  572.     a0 = buffer;
  573.     __asm volatile
  574.         ("movel a6, sp@-
  575.           movel _ArpBase, a6
  576.           jsr a6@(-246)
  577.           movel sp@+, a6"
  578.         : "=g"(res): "g"(a0)
  579.         : "d1", "a0", "a1");
  580.     return res;
  581. }
  582.  
  583. long
  584. GADS(char * line, long len, char * help, char ** args, char * tplate);
  585.  
  586. long
  587. Atol(const char * string);
  588.  
  589. __inline static unsigned long
  590. EscapeString(char * string)
  591. {
  592.     register char * a0 __asm("a0");
  593.     register unsigned long res __asm("d0");
  594.     a0 = string;
  595.     __asm volatile
  596.         ("movel a6, sp@-
  597.           movel _ArpBase, a6
  598.           jsr a6@(-264)
  599.           movel sp@+, a6"
  600.         : "=g"(res): "g"(a0)
  601.         : "d1", "a0", "a1");
  602.     return res;
  603. }
  604.  
  605. __inline static long
  606. CheckAbort(void (*func)())
  607. {
  608.     register void (*a1)() __asm("a1");
  609.     register long res __asm("d0");
  610.     a1 = func;
  611.     __asm volatile
  612.         ("movel a6, sp@-
  613.           movel _ArpBase, a6
  614.           jsr a6@(-270)
  615.           movel sp@+, a6"
  616.         : "=g"(res): "g"(a1)
  617.         : "d1", "a0", "a1");
  618.     return res;
  619. }
  620.  
  621. __inline static long
  622. CheckBreak(long masks, void (*func)())
  623. {
  624.     register long d1 __asm("d1");
  625.     register void (*a1)() __asm("a1");
  626.     register long res __asm("d0");
  627.     d1 = masks;
  628.     a1 = func;
  629.     __asm volatile
  630.         ("movel a6, sp@-
  631.           movel _ArpBase, a6
  632.           jsr a6@(-276)
  633.           movel sp@+, a6"
  634.         : "=g"(res): "g"(d1), "g"(a1)
  635.         : "d1", "a0", "a1");
  636.     return res;
  637. }
  638.  
  639. __inline static char *
  640. Getenv(const char * string, char * buffer, long size)
  641. {
  642.     register const char * a0 __asm("a0");
  643.     register char * a1 __asm("a1");
  644.     register long d0 __asm("d0");
  645.     register char * res __asm("d0");
  646.     a0 = string;
  647.     a1 = buffer;
  648.     d0 = size;
  649.     __asm volatile
  650.         ("movel a6, sp@-
  651.           movel _ArpBase, a6
  652.           jsr a6@(-282)
  653.           movel sp@+, a6"
  654.         : "=g"(res): "g"(a0), "g"(a1), "g"(d0)
  655.         : "d1", "a0", "a1");
  656.     return res;
  657. }
  658.  
  659. __inline static BOOL
  660. Setenv(const char * varname, char * value)
  661. {
  662.     register const char * a0 __asm("a0");
  663.     register char * a1 __asm("a1");
  664.     register BOOL res __asm("d0");
  665.     a0 = varname;
  666.     a1 = value;
  667.     __asm volatile
  668.         ("movel a6, sp@-
  669.           movel _ArpBase, a6
  670.           jsr a6@(-288)
  671.           movel sp@+, a6"
  672.         : "=g"(res): "g"(a0), "g"(a1)
  673.         : "d1", "a0", "a1");
  674.     return res;
  675. }
  676.  
  677. __inline static char *
  678. FileRequest(struct FileRequester * FileRequester)
  679. {
  680.     register struct FileRequester * a0 __asm("a0");
  681.     register char * res __asm("d0");
  682.     a0 = FileRequester;
  683.     __asm volatile
  684.         ("movel a6, sp@-
  685.           movel _ArpBase, a6
  686.           jsr a6@(-294)
  687.           movel sp@+, a6"
  688.         : "=g"(res): "g"(a0)
  689.         : "d1", "a0", "a1");
  690.     return res;
  691. }
  692.  
  693. __inline static void
  694. CloseWindowSafely(struct Window * Window1, long Window2)
  695. {
  696.     register struct Window * a0 __asm("a0");
  697.     register long a1 __asm("a1");
  698.     a0 = Window1;
  699.     a1 = Window2;
  700.     __asm volatile
  701.         ("movel a6, sp@-
  702.           movel _ArpBase, a6
  703.           jsr a6@(-300)
  704.           movel sp@+, a6"
  705.         : : "g"(a0), "g"(a1)
  706.         : "d0", "d1", "a0", "a1");
  707. }
  708.  
  709. __inline static struct MsgPort *
  710. CreatePort(const char * name, long pri)
  711. {
  712.     register const char * a0 __asm("a0");
  713.     register long d0 __asm("d0");
  714.     register struct MsgPort * res __asm("d0");
  715.     a0 = name;
  716.     d0 = pri;
  717.     __asm volatile
  718.         ("movel a6, sp@-
  719.           movel _ArpBase, a6
  720.           jsr a6@(-306)
  721.           movel sp@+, a6"
  722.         : "=g"(res): "g"(a0), "g"(d0)
  723.         : "d1", "a0", "a1");
  724.     return res;
  725. }
  726.  
  727. __inline static void
  728. DeletePort(struct MsgPort * port)
  729. {
  730.     register struct MsgPort * a1 __asm("a1");
  731.     a1 = port;
  732.     __asm volatile
  733.         ("movel a6, sp@-
  734.           movel _ArpBase, a6
  735.           jsr a6@(-312)
  736.           movel sp@+, a6"
  737.         : : "g"(a1)
  738.         : "d0", "d1", "a0", "a1");
  739. }
  740.  
  741. __inline static long
  742. SendPacket(long action, long * args, struct MsgPort * handler)
  743. {
  744.     register long d0 __asm("d0");
  745.     register long * a0 __asm("a0");
  746.     register struct MsgPort * a1 __asm("a1");
  747.     register long res __asm("d0");
  748.     d0 = action;
  749.     a0 = args;
  750.     a1 = handler;
  751.     __asm volatile
  752.         ("movel a6, sp@-
  753.           movel _ArpBase, a6
  754.           jsr a6@(-318)
  755.           movel sp@+, a6"
  756.         : "=g"(res): "g"(d0), "g"(a0), "g"(a1)
  757.         : "d1", "a0", "a1");
  758.     return res;
  759. }
  760.  
  761. __inline static void
  762. InitStdPacket(long action, long * args, struct DosPacket * packet, struct MsgPort * replyport)
  763. {
  764.     register long d0 __asm("d0");
  765.     register long * a0 __asm("a0");
  766.     register struct DosPacket * a1 __asm("a1");
  767.     register struct MsgPort * a2 __asm("a2");
  768.     d0 = action;
  769.     a0 = args;
  770.     a1 = packet;
  771.     a2 = replyport;
  772.     __asm volatile
  773.         ("movel a6, sp@-
  774.           movel _ArpBase, a6
  775.           jsr a6@(-324)
  776.           movel sp@+, a6"
  777.         : : "g"(d0), "g"(a0), "g"(a1), "g"(a2)
  778.         : "d0", "d1", "a0", "a1", "a2");
  779. }
  780.  
  781. __inline static unsigned long
  782. PathName(BPTR lock, char * buffer, long componentcount)
  783. {
  784.     register BPTR d0 __asm("d0");
  785.     register char * a0 __asm("a0");
  786.     register long d1 __asm("d1");
  787.     register unsigned long res __asm("d0");
  788.     d0 = lock;
  789.     a0 = buffer;
  790.     d1 = componentcount;
  791.     __asm volatile
  792.         ("movel a6, sp@-
  793.           movel _ArpBase, a6
  794.           jsr a6@(-330)
  795.           movel sp@+, a6"
  796.         : "=g"(res): "g"(d0), "g"(a0), "g"(d1)
  797.         : "d1", "a0", "a1");
  798.     return res;
  799. }
  800.  
  801. __inline static unsigned long
  802. Assign(const char * logical, const char * physical)
  803. {
  804.     register const char * a0 __asm("a0");
  805.     register const char * a1 __asm("a1");
  806.     register unsigned long res __asm("d0");
  807.     a0 = logical;
  808.     a1 = physical;
  809.     __asm volatile
  810.         ("movel a6, sp@-
  811.           movel _ArpBase, a6
  812.           jsr a6@(-336)
  813.           movel sp@+, a6"
  814.         : "=g"(res): "g"(a0), "g"(a1)
  815.         : "d1", "a0", "a1");
  816.     return res;
  817. }
  818.  
  819. __inline static void *
  820. DosAllocMem(long size)
  821. {
  822.     register long d0 __asm("d0");
  823.     register void * res __asm("d0");
  824.     d0 = size;
  825.     __asm volatile
  826.         ("movel a6, sp@-
  827.           movel _ArpBase, a6
  828.           jsr a6@(-342)
  829.           movel sp@+, a6"
  830.         : "=g"(res): "g"(d0)
  831.         : "d1", "a0", "a1");
  832.     return res;
  833. }
  834.  
  835. __inline static void
  836. DosFreeMem(void * dosblock)
  837. {
  838.     register void * a1 __asm("a1");
  839.     a1 = dosblock;
  840.     __asm volatile
  841.         ("movel a6, sp@-
  842.           movel _ArpBase, a6
  843.           jsr a6@(-348)
  844.           movel sp@+, a6"
  845.         : : "g"(a1)
  846.         : "d0", "d1", "a0", "a1");
  847. }
  848.  
  849. __inline static unsigned long
  850. BtoCStr(char * cstr, BSTR bstr, long maxlength)
  851. {
  852.     register char * a0 __asm("a0");
  853.     register BSTR d0 __asm("d0");
  854.     register long d1 __asm("d1");
  855.     register unsigned long res __asm("d0");
  856.     a0 = cstr;
  857.     d0 = bstr;
  858.     d1 = maxlength;
  859.     __asm volatile
  860.         ("movel a6, sp@-
  861.           movel _ArpBase, a6
  862.           jsr a6@(-354)
  863.           movel sp@+, a6"
  864.         : "=g"(res): "g"(a0), "g"(d0), "g"(d1)
  865.         : "d1", "a0", "a1");
  866.     return res;
  867. }
  868.  
  869. __inline static unsigned long
  870. CtoBstr(const char * cstr, BSTR bstr, long maxlength)
  871. {
  872.     register const char * a0 __asm("a0");
  873.     register BSTR d0 __asm("d0");
  874.     register long d1 __asm("d1");
  875.     register unsigned long res __asm("d0");
  876.     a0 = cstr;
  877.     d0 = bstr;
  878.     d1 = maxlength;
  879.     __asm volatile
  880.         ("movel a6, sp@-
  881.           movel _ArpBase, a6
  882.           jsr a6@(-360)
  883.           movel sp@+, a6"
  884.         : "=g"(res): "g"(a0), "g"(d0), "g"(d1)
  885.         : "d1", "a0", "a1");
  886.     return res;
  887. }
  888.  
  889. __inline static struct DeviceList *
  890. GetDevInfo(struct DeviceList * devnode)
  891. {
  892.     register struct DeviceList * a2 __asm("a2");
  893.     register struct DeviceList * res __asm("d0");
  894.     a2 = devnode;
  895.     __asm volatile
  896.         ("movel a6, sp@-
  897.           movel _ArpBase, a6
  898.           jsr a6@(-366)
  899.           movel sp@+, a6"
  900.         : "=g"(res): "g"(a2)
  901.         : "d1", "a0", "a1", "a2");
  902.     return res;
  903. }
  904.  
  905. __inline static BOOL
  906. FreeTaskResList(void)
  907. {
  908.     register BOOL res __asm("d0");
  909.     __asm volatile
  910.         ("movel a6, sp@-
  911.           movel _ArpBase, a6
  912.           jsr a6@(-372)
  913.           movel sp@+, a6"
  914.         : "=g"(res):
  915.         : "d1", "a0", "a1");
  916.     return res;
  917. }
  918.  
  919. __inline static void
  920. ArpExit(long rc, long result2)
  921. {
  922.     register long d0 __asm("d0");
  923.     register long d2 __asm("d2");
  924.     d0 = rc;
  925.     d2 = result2;
  926.     __asm volatile
  927.         ("movel a6, sp@-
  928.           movel _ArpBase, a6
  929.           jsr a6@(-378)
  930.           movel sp@+, a6"
  931.         : : "g"(d0), "g"(d2)
  932.         : "d0", "d1", "d2", "a0", "a1");
  933. }
  934.  
  935. void *
  936. ArpAlloc(long size);
  937.  
  938. void *
  939. ArpAllocMem(long size, long requirements);
  940.  
  941. BPTR
  942. ArpOpen(const char * name, long mode);
  943.  
  944. BPTR
  945. ArpDupLock(BPTR lock);
  946.  
  947. BPTR
  948. ArpLock(const char * name, long mode);
  949.  
  950. void *
  951. RListAlloc(struct ArpResList * reslist,  long size);
  952.  
  953. __inline static struct Process *
  954. FindCLI(long clinum)
  955. {
  956.     register long d0 __asm("d0");
  957.     register struct Process * res __asm("d0");
  958.     d0 = clinum;
  959.     __asm volatile
  960.         ("movel a6, sp@-
  961.           movel _ArpBase, a6
  962.           jsr a6@(-420)
  963.           movel sp@+, a6"
  964.         : "=g"(res): "g"(d0)
  965.         : "d1", "a0", "a1");
  966.     return res;
  967. }
  968.  
  969. __inline static BOOL
  970. QSort(void * base, long rsize, long bsize, int (*comp)())
  971. {
  972.     register void * a0 __asm("a0");
  973.     register long d0 __asm("d0");
  974.     register long d1 __asm("d1");
  975.     register int (*a1)() __asm("a1");
  976.     register BOOL res __asm("d0");
  977.     a0 = base;
  978.     d0 = rsize;
  979.     d1 = bsize;
  980.     a1 = comp;
  981.     __asm volatile
  982.         ("movel a6, sp@-
  983.           movel _ArpBase, a6
  984.           jsr a6@(-426)
  985.           movel sp@+, a6"
  986.         : "=g"(res): "g"(a0), "g"(d0), "g"(d1), "g"(a1)
  987.         : "d1", "a0", "a1");
  988.     return res;
  989. }
  990.  
  991. __inline static BOOL
  992. PatternMatch(const char * pattern, const char * string)
  993. {
  994.     register const char * a0 __asm("a0");
  995.     register const char * a1 __asm("a1");
  996.     register BOOL res __asm("d0");
  997.     a0 = pattern;
  998.     a1 = string;
  999.     __asm volatile
  1000.         ("movel a6, sp@-
  1001.           movel _ArpBase, a6
  1002.           jsr a6@(-432)
  1003.           movel sp@+, a6"
  1004.         : "=g"(res): "g"(a0), "g"(a1)
  1005.         : "d1", "a0", "a1");
  1006.     return res;
  1007. }
  1008.  
  1009. __inline static long
  1010. FindFirst(char * pattern, struct AnchorPath * AnchorPath)
  1011. {
  1012.     register char * d0 __asm("d0");
  1013.     register struct AnchorPath * a0 __asm("a0");
  1014.     register long res __asm("d0");
  1015.     d0 = pattern;
  1016.     a0 = AnchorPath;
  1017.     __asm volatile
  1018.         ("movel a6, sp@-
  1019.           movel _ArpBase, a6
  1020.           jsr a6@(-438)
  1021.           movel sp@+, a6"
  1022.         : "=g"(res): "g"(d0), "g"(a0)
  1023.         : "d1", "a0", "a1");
  1024.     return res;
  1025. }
  1026.  
  1027. __inline static long
  1028. FindNext(struct AnchorPath * AnchorPath)
  1029. {
  1030.     register struct AnchorPath * a0 __asm("a0");
  1031.     register long res __asm("d0");
  1032.     a0 = AnchorPath;
  1033.     __asm volatile
  1034.         ("movel a6, sp@-
  1035.           movel _ArpBase, a6
  1036.           jsr a6@(-444)
  1037.           movel sp@+, a6"
  1038.         : "=g"(res): "g"(a0)
  1039.         : "d1", "a0", "a1");
  1040.     return res;
  1041. }
  1042.  
  1043. __inline static void
  1044. FreeAnchorChain(struct AnchorPath * AnchorPath)
  1045. {
  1046.     register struct AnchorPath * a0 __asm("a0");
  1047.     a0 = AnchorPath;
  1048.     __asm volatile
  1049.         ("movel a6, sp@-
  1050.           movel _ArpBase, a6
  1051.           jsr a6@(-450)
  1052.           movel sp@+, a6"
  1053.         : : "g"(a0)
  1054.         : "d0", "d1", "a0", "a1");
  1055. }
  1056.  
  1057. __inline static unsigned long
  1058. CompareLock(BPTR lock1, BPTR lock2)
  1059. {
  1060.     register BPTR d0 __asm("d0");
  1061.     register BPTR d1 __asm("d1");
  1062.     register unsigned long res __asm("d0");
  1063.     d0 = lock1;
  1064.     d1 = lock2;
  1065.     __asm volatile
  1066.         ("movel a6, sp@-
  1067.           movel _ArpBase, a6
  1068.           jsr a6@(-456)
  1069.           movel sp@+, a6"
  1070.         : "=g"(res): "g"(d0), "g"(d1)
  1071.         : "d1", "a0", "a1");
  1072.     return res;
  1073. }
  1074.  
  1075. __inline static struct ArpResList *
  1076. FindTaskResList(void)
  1077. {
  1078.     register struct ArpResList * res __asm("d0");
  1079.     __asm volatile
  1080.         ("movel a6, sp@-
  1081.           movel _ArpBase, a6
  1082.           jsr a6@(-462)
  1083.           movel sp@+, a6"
  1084.         : "=g"(res):
  1085.         : "d1", "a0", "a1");
  1086.     return res;
  1087. }
  1088.  
  1089. __inline static struct ArpResList *
  1090. CreateTaskResList(void)
  1091. {
  1092.     register struct ArpResList * res __asm("d0");
  1093.     __asm volatile
  1094.         ("movel a6, sp@-
  1095.           movel _ArpBase, a6
  1096.           jsr a6@(-468)
  1097.           movel sp@+, a6"
  1098.         : "=g"(res):
  1099.         : "d1", "a0", "a1");
  1100.     return res;
  1101. }
  1102.  
  1103. __inline static void
  1104. FreeResList(struct ArpResList * freelist)
  1105. {
  1106.     register struct ArpResList * a1 __asm("a1");
  1107.     a1 = freelist;
  1108.     __asm volatile
  1109.         ("movel a6, sp@-
  1110.           movel _ArpBase, a6
  1111.           jsr a6@(-474)
  1112.           movel sp@+, a6"
  1113.         : : "g"(a1)
  1114.         : "d0", "d1", "a0", "a1");
  1115. }
  1116.  
  1117. __inline static void
  1118. FreeTrackedItem(struct DefaultTracker * item)
  1119. {
  1120.     register struct DefaultTracker * a1 __asm("a1");
  1121.     a1 = item;
  1122.     __asm volatile
  1123.         ("movel a6, sp@-
  1124.           movel _ArpBase, a6
  1125.           jsr a6@(-480)
  1126.           movel sp@+, a6"
  1127.         : : "g"(a1)
  1128.         : "d0", "d1", "a0", "a1");
  1129. }
  1130.  
  1131. struct DefaultTracker *
  1132. GetTracker(void);
  1133.  
  1134. __inline static void *
  1135. GetAccess(struct DefaultTracker * tracker)
  1136. {
  1137.     register struct DefaultTracker * a1 __asm("a1");
  1138.     register void * res __asm("d0");
  1139.     a1 = tracker;
  1140.     __asm volatile
  1141.         ("movel a6, sp@-
  1142.           movel _ArpBase, a6
  1143.           jsr a6@(-492)
  1144.           movel sp@+, a6"
  1145.         : "=g"(res): "g"(a1)
  1146.         : "d1", "a0", "a1");
  1147.     return res;
  1148. }
  1149.  
  1150. __inline static void
  1151. FreeAccess(struct DefaultTracker * tracker)
  1152. {
  1153.     register struct DefaultTracker * a1 __asm("a1");
  1154.     a1 = tracker;
  1155.     __asm volatile
  1156.         ("movel a6, sp@-
  1157.           movel _ArpBase, a6
  1158.           jsr a6@(-498)
  1159.           movel sp@+, a6"
  1160.         : : "g"(a1)
  1161.         : "d0", "d1", "a0", "a1");
  1162. }
  1163.  
  1164. __inline static void
  1165. FreeDAList(struct DirectoryEntry * node)
  1166. {
  1167.     register struct DirectoryEntry * a1 __asm("a1");
  1168.     a1 = node;
  1169.     __asm volatile
  1170.         ("movel a6, sp@-
  1171.           movel _ArpBase, a6
  1172.           jsr a6@(-504)
  1173.           movel sp@+, a6"
  1174.         : : "g"(a1)
  1175.         : "d0", "d1", "a0", "a1");
  1176. }
  1177.  
  1178. __inline static struct DirectoryEntry *
  1179. AddDANode(char * data, struct DirectoryEntry ** dalist, long length, long id)
  1180. {
  1181.     register char * a0 __asm("a0");
  1182.     register struct DirectoryEntry ** a1 __asm("a1");
  1183.     register long d0 __asm("d0");
  1184.     register long d1 __asm("d1");
  1185.     register struct DirectoryEntry * res __asm("d0");
  1186.     a0 = data;
  1187.     a1 = dalist;
  1188.     d0 = length;
  1189.     d1 = id;
  1190.     __asm volatile
  1191.         ("movel a6, sp@-
  1192.           movel _ArpBase, a6
  1193.           jsr a6@(-510)
  1194.           movel sp@+, a6"
  1195.         : "=g"(res): "g"(a0), "g"(a1), "g"(d0), "g"(d1)
  1196.         : "d1", "a0", "a1");
  1197.     return res;
  1198. }
  1199.  
  1200. __inline static unsigned long
  1201. AddDADevs(struct DirectoryEntry ** dalist, long select)
  1202. {
  1203.     register struct DirectoryEntry ** a0 __asm("a0");
  1204.     register long d0 __asm("d0");
  1205.     register unsigned long res __asm("d0");
  1206.     a0 = dalist;
  1207.     d0 = select;
  1208.     __asm volatile
  1209.         ("movel a6, sp@-
  1210.           movel _ArpBase, a6
  1211.           jsr a6@(-516)
  1212.           movel sp@+, a6"
  1213.         : "=g"(res): "g"(a0), "g"(d0)
  1214.         : "d1", "a0", "a1");
  1215.     return res;
  1216. }
  1217.  
  1218. __inline static long
  1219. Strcmp(const char * s1, const char * s2)
  1220. {
  1221.     register const char * a0 __asm("a0");
  1222.     register const char * a1 __asm("a1");
  1223.     register long res __asm("d0");
  1224.     a0 = s1;
  1225.     a1 = s2;
  1226.     __asm volatile
  1227.         ("movel a6, sp@-
  1228.           movel _ArpBase, a6
  1229.           jsr a6@(-522)
  1230.           movel sp@+, a6"
  1231.         : "=g"(res): "g"(a0), "g"(a1)
  1232.         : "d1", "a0", "a1");
  1233.     return res;
  1234. }
  1235.  
  1236. __inline static long
  1237. Strncmp(const char * s1, const char * s2, long count)
  1238. {
  1239.     register const char * a0 __asm("a0");
  1240.     register const char * a1 __asm("a1");
  1241.     register long d0 __asm("d0");
  1242.     register long res __asm("d0");
  1243.     a0 = s1;
  1244.     a1 = s2;
  1245.     d0 = count;
  1246.     __asm volatile
  1247.         ("movel a6, sp@-
  1248.           movel _ArpBase, a6
  1249.           jsr a6@(-528)
  1250.           movel sp@+, a6"
  1251.         : "=g"(res): "g"(a0), "g"(a1), "g"(d0)
  1252.         : "d1", "a0", "a1");
  1253.     return res;
  1254. }
  1255.  
  1256. __inline static char
  1257. Toupper(char character)
  1258. {
  1259.     register char d0 __asm("d0");
  1260.     register char res __asm("d0");
  1261.     d0 = character;
  1262.     __asm volatile
  1263.         ("movel a6, sp@-
  1264.           movel _ArpBase, a6
  1265.           jsr a6@(-534)
  1266.           movel sp@+, a6"
  1267.         : "=g"(res): "g"(d0)
  1268.         : "d1", "a0", "a1");
  1269.     return res;
  1270. }
  1271.  
  1272. __inline static long
  1273. SyncRun(const char * name, const char * command, BPTR input, BPTR output)
  1274. {
  1275.     register const char * a0 __asm("a0");
  1276.     register const char * a1 __asm("a1");
  1277.     register BPTR d0 __asm("d0");
  1278.     register BPTR d1 __asm("d1");
  1279.     register long res __asm("d0");
  1280.     a0 = name;
  1281.     a1 = command;
  1282.     d0 = input;
  1283.     d1 = output;
  1284.     __asm volatile
  1285.         ("movel a6, sp@-
  1286.           movel _ArpBase, a6
  1287.           jsr a6@(-540)
  1288.           movel sp@+, a6"
  1289.         : "=g"(res): "g"(a0), "g"(a1), "g"(d0), "g"(d1)
  1290.         : "d1", "a0", "a1");
  1291.     return res;
  1292. }
  1293.  
  1294. __inline static long
  1295. ASyncRun(const char * name, const char * command, struct ProcessControlBlock * pcb)
  1296. {
  1297.     register const char * a0 __asm("a0");
  1298.     register const char * a1 __asm("a1");
  1299.     register struct ProcessControlBlock * a2 __asm("a2");
  1300.     register long res __asm("d0");
  1301.     a0 = name;
  1302.     a1 = command;
  1303.     a2 = pcb;
  1304.     __asm volatile
  1305.         ("movel a6, sp@-
  1306.           movel _ArpBase, a6
  1307.           jsr a6@(-546)
  1308.           movel sp@+, a6"
  1309.         : "=g"(res): "g"(a0), "g"(a1), "g"(a2)
  1310.         : "d1", "a0", "a1", "a2");
  1311.     return res;
  1312. }
  1313.  
  1314. __inline static BPTR
  1315. LoadPrg(const char * name)
  1316. {
  1317.     register const char * d1 __asm("d1");
  1318.     register BPTR res __asm("d0");
  1319.     d1 = name;
  1320.     __asm volatile
  1321.         ("movel a6, sp@-
  1322.           movel _ArpBase, a6
  1323.           jsr a6@(-552)
  1324.           movel sp@+, a6"
  1325.         : "=g"(res): "g"(d1)
  1326.         : "d1", "a0", "a1");
  1327.     return res;
  1328. }
  1329.  
  1330. __inline static BOOL
  1331. PreParse(const char * source, char * dest)
  1332. {
  1333.     register const char * a0 __asm("a0");
  1334.     register char * a1 __asm("a1");
  1335.     register BOOL res __asm("d0");
  1336.     a0 = source;
  1337.     a1 = dest;
  1338.     __asm volatile
  1339.         ("movel a6, sp@-
  1340.           movel _ArpBase, a6
  1341.           jsr a6@(-558)
  1342.           movel sp@+, a6"
  1343.         : "=g"(res): "g"(a0), "g"(a1)
  1344.         : "d1", "a0", "a1");
  1345.     return res;
  1346. }
  1347.  
  1348. __inline static BOOL
  1349. StamptoStr(struct DateTime * datetime)
  1350. {
  1351.     register struct DateTime * a0 __asm("a0");
  1352.     register BOOL res __asm("d0");
  1353.     a0 = datetime;
  1354.     __asm volatile
  1355.         ("movel a6, sp@-
  1356.           movel _ArpBase, a6
  1357.           jsr a6@(-564)
  1358.           movel sp@+, a6"
  1359.         : "=g"(res): "g"(a0)
  1360.         : "d1", "a0", "a1");
  1361.     return res;
  1362. }
  1363.  
  1364. __inline static BOOL
  1365. StrtoStamp(struct DateTime * datetime)
  1366. {
  1367.     register struct DateTime * a0 __asm("a0");
  1368.     register BOOL res __asm("d0");
  1369.     a0 = datetime;
  1370.     __asm volatile
  1371.         ("movel a6, sp@-
  1372.           movel _ArpBase, a6
  1373.           jsr a6@(-570)
  1374.           movel sp@+, a6"
  1375.         : "=g"(res): "g"(a0)
  1376.         : "d1", "a0", "a1");
  1377.     return res;
  1378. }
  1379.  
  1380. __inline static struct ResidentProgramNode *
  1381. ObtainResidentPrg(const char * name)
  1382. {
  1383.     register const char * a0 __asm("a0");
  1384.     register struct ResidentProgramNode * res __asm("d0");
  1385.     a0 = name;
  1386.     __asm volatile
  1387.         ("movel a6, sp@-
  1388.           movel _ArpBase, a6
  1389.           jsr a6@(-576)
  1390.           movel sp@+, a6"
  1391.         : "=g"(res): "g"(a0)
  1392.         : "d1", "a0", "a1");
  1393.     return res;
  1394. }
  1395.  
  1396. __inline static struct ResidentProgramNode *
  1397. AddResidentPrg(BPTR Segment, const char * name)
  1398. {
  1399.     register BPTR d1 __asm("d1");
  1400.     register const char * a0 __asm("a0");
  1401.     register struct ResidentProgramNode * res __asm("d0");
  1402.     d1 = Segment;
  1403.     a0 = name;
  1404.     __asm volatile
  1405.         ("movel a6, sp@-
  1406.           movel _ArpBase, a6
  1407.           jsr a6@(-582)
  1408.           movel sp@+, a6"
  1409.         : "=g"(res): "g"(d1), "g"(a0)
  1410.         : "d1", "a0", "a1");
  1411.     return res;
  1412. }
  1413.  
  1414. __inline static long
  1415. RemResidentPrg(const char * name)
  1416. {
  1417.     register const char * a0 __asm("a0");
  1418.     register long res __asm("d0");
  1419.     a0 = name;
  1420.     __asm volatile
  1421.         ("movel a6, sp@-
  1422.           movel _ArpBase, a6
  1423.           jsr a6@(-588)
  1424.           movel sp@+, a6"
  1425.         : "=g"(res): "g"(a0)
  1426.         : "d1", "a0", "a1");
  1427.     return res;
  1428. }
  1429.  
  1430. __inline static void
  1431. UnLoadPrg(BPTR segment)
  1432. {
  1433.     register BPTR d1 __asm("d1");
  1434.     d1 = segment;
  1435.     __asm volatile
  1436.         ("movel a6, sp@-
  1437.           movel _ArpBase, a6
  1438.           jsr a6@(-594)
  1439.           movel sp@+, a6"
  1440.         : : "g"(d1)
  1441.         : "d0", "d1", "a0", "a1");
  1442. }
  1443.  
  1444. __inline static long
  1445. LMult(long a, long b)
  1446. {
  1447.     register long d0 __asm("d0");
  1448.     register long d1 __asm("d1");
  1449.     register long res __asm("d0");
  1450.     d0 = a;
  1451.     d1 = b;
  1452.     __asm volatile
  1453.         ("movel a6, sp@-
  1454.           movel _ArpBase, a6
  1455.           jsr a6@(-600)
  1456.           movel sp@+, a6"
  1457.         : "=g"(res): "g"(d0), "g"(d1)
  1458.         : "d1", "a0", "a1");
  1459.     return res;
  1460. }
  1461.  
  1462. __inline static long
  1463. LDiv(long a, long b)
  1464. {
  1465.     register long d0 __asm("d0");
  1466.     register long d1 __asm("d1");
  1467.     register long res __asm("d0");
  1468.     d0 = a;
  1469.     d1 = b;
  1470.     __asm volatile
  1471.         ("movel a6, sp@-
  1472.           movel _ArpBase, a6
  1473.           jsr a6@(-606)
  1474.           movel sp@+, a6"
  1475.         : "=g"(res): "g"(d0), "g"(d1)
  1476.         : "d1", "a0", "a1");
  1477.     return res;
  1478. }
  1479.  
  1480. __inline static long
  1481. LMod(long a, long b)
  1482. {
  1483.     register long d0 __asm("d0");
  1484.     register long d1 __asm("d1");
  1485.     register long res __asm("d0");
  1486.     d0 = a;
  1487.     d1 = b;
  1488.     __asm volatile
  1489.         ("movel a6, sp@-
  1490.           movel _ArpBase, a6
  1491.           jsr a6@(-612)
  1492.           movel sp@+, a6"
  1493.         : "=g"(res): "g"(d0), "g"(d1)
  1494.         : "d1", "a0", "a1");
  1495.     return res;
  1496. }
  1497.  
  1498. __inline static unsigned long
  1499. CheckSumPrg(struct ResidentProgramNode * ResidentNode)
  1500. {
  1501.     register struct ResidentProgramNode * d0 __asm("d0");
  1502.     register unsigned long res __asm("d0");
  1503.     d0 = ResidentNode;
  1504.     __asm volatile
  1505.         ("movel a6, sp@-
  1506.           movel _ArpBase, a6
  1507.           jsr a6@(-618)
  1508.           movel sp@+, a6"
  1509.         : "=g"(res): "g"(d0)
  1510.         : "d1", "a0", "a1");
  1511.     return res;
  1512. }
  1513.  
  1514. __inline static void
  1515. TackOn(char * pathname, const char * filename)
  1516. {
  1517.     register char * a0 __asm("a0");
  1518.     register const char * a1 __asm("a1");
  1519.     a0 = pathname;
  1520.     a1 = filename;
  1521.     __asm volatile
  1522.         ("movel a6, sp@-
  1523.           movel _ArpBase, a6
  1524.           jsr a6@(-624)
  1525.           movel sp@+, a6"
  1526.         : : "g"(a0), "g"(a1)
  1527.         : "d0", "d1", "a0", "a1");
  1528. }
  1529.  
  1530. __inline static char *
  1531. BaseName(const char * name)
  1532. {
  1533.     register const char * a0 __asm("a0");
  1534.     register char * res __asm("d0");
  1535.     a0 = name;
  1536.     __asm volatile
  1537.         ("movel a6, sp@-
  1538.           movel _ArpBase, a6
  1539.           jsr a6@(-630)
  1540.           movel sp@+, a6"
  1541.         : "=g"(res): "g"(a0)
  1542.         : "d1", "a0", "a1");
  1543.     return res;
  1544. }
  1545.  
  1546. __inline static struct ResidentProgramNode *
  1547. ReleaseResidentPrg(BPTR segment)
  1548. {
  1549.     register BPTR d1 __asm("d1");
  1550.     register struct ResidentProgramNode * res __asm("d0");
  1551.     d1 = segment;
  1552.     __asm volatile
  1553.         ("movel a6, sp@-
  1554.           movel _ArpBase, a6
  1555.           jsr a6@(-636)
  1556.           movel sp@+, a6"
  1557.         : "=g"(res): "g"(d1)
  1558.         : "d1", "a0", "a1");
  1559.     return res;
  1560. }
  1561.  
  1562. #endif /* ARPFUNCTIONS_H */
  1563.